/**
 * @(#)$CurrentFile
 * 版权声明 厦门亿力吉奥软件公司, 版权所有 违者必究
 *
 *<br> Copyright:  Copyright (c) 2006
 *<br> Company:厦门亿力吉奥软件公司
 *<br> @author 耿渊
 *<br> 2007-07-01
 *<br> @version 1.0
 *————————————————————————————————————
 *修改记录
 *    修改者：
 *    修改时间：
 *    修改原因：
 *——————————————————————————————————————
 */
package com.sunsharing.flow.model.node;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.HashSet;

import com.sunsharing.common.anno.Factory;
import com.sunsharing.flow.event.NodeEnterEvent;
import com.sunsharing.flow.event.NodeLeaveEvent;
import com.sunsharing.flow.exe.ExecutionContext;
import com.sunsharing.flow.model.Node;


/**
 *<pre>Event</pre>
 *<br>--------------------------------------------------------------------------
 *<br> <b>功能描述:</b>
 *<br>   任务节点
 *<br> 注意事项:
 *<br> jdk 1.4
 *<br> jsp 1.2
 *<br>--------------------------------------------------------------------------
 *<br>
 */
@Factory(key="TaskNode")
public class TaskNode extends Node {

    //支持的事件类型
    public static final Class[] supportedEventTypes = new Class[] {
            NodeEnterEvent.class, NodeLeaveEvent.class
//            , TaskCreateEvent.class,
//            TaskAssignEvent.class, TaskEndEvent.class, TaskItemCreateEvent.class,
//            TaskItemEndEvent.class, TaskItemSignInEvent.class,
//            TaskItemCancleSignInEvent.class
    };


    public TaskNode() {
    }

    Call callChain = null;

    public Call getCallChain() {
        return callChain;
    }

    public void setCallChain(Call callChain) {
        this.callChain = callChain;
    }

    public Class[] getSupportedEventTypes() {
        return supportedEventTypes;
    }

    public void setCall(Call call)
    {
        this.callChain = call;
    }


    /**
     * 功能描述:
     *     执行
     * @param executeContext ExecutionContext
     */
    public void execute(ExecutionContext executeContext) {

        //把当前节点加入执行节点
        executeContext.getToken().addExecutedNode(this);

//        TaskFactory factory = new TaskFactory();
//        //创建任务
//        AbstractTask task = factory.createTask(executeContext);
//        //对任务进行初始化
//        task.init(executeContext);

        callChain.call(executeContext);
        if(callChain instanceof WebServiceCall)
        {
            logger.info("外部服务调用，走异步");
            return;
        }
        leave(executeContext);

    }

    public void leave(ExecutionContext executeContext) {

        logger.debug("离开任务节点...");
        executeContext.getToken().signal();
    }


    /**
     * 功能描述:
     *     撤回
     * @param node Node
     */
//    public boolean rollback(ExecutionContext executeContext, Node backNode) {
//
//        //获得当前执行顺序号
//        int position = ((Integer) executeContext.getParameter(
//                ExecutionContext.EXECUTED_NODE_POSITION)).intValue();
//
//        Token token = executeContext.getToken();
//        //如果当前节点为回退节点
//        if (this.equals(backNode)) {
//
//            //清除该token的结束时间
//            token.setEndTime("");
//            //设置该状态为运行状态
//            token.setStatus(Token.STATUS_RUN);
//            //设置该令牌的当前执行节点
//            token.setNode(this);
//            //移除所有该节点之后的已执行节点的任务
//            List<ExecutedNode>
//                    executedNodes = token.getAllAfterExecutedNode(position); //token.getAllAfterExecutedNode(this);
//            Iterator itor = executedNodes.iterator();
//            while (itor.hasNext()) {
//                ExecutedNode executedNode = (ExecutedNode) itor.next();
//                token.removeTask(executedNode.getNode());
//
//            }
//
//            //移除执行的节点
//            //token.removeAllAfterExecutedNode(this);
//            token.removeAllAfterExecutedNode(position);
//            //获得流程实例
//            ProcessInstance instance = token.getProcessInstance();
//            AbstractTask task = AbstractTask.getTask(instance, this);
//            task.reInit(executeContext);
//            return true;
//        }
//
//        //获得上一个节点
//        Node previousNode = token.getPreviousExecutedNode(position); //token.getPreviousExecutedNode(this);
//
//        executeContext.addParameter(ExecutionContext.EXECUTED_NODE_POSITION,
//                                    new Integer(position - 1));
//        return previousNode.rollback(executeContext, backNode);
//
//    }


    /**
     * 功能描述:
     *    撤回
     * @param executeContext ExecutionContext
     * @return boolean
     */
//    public void withdraw(ExecutionContext executeContext) {
//
//        //获得令牌
//        Token token = executeContext.getToken();
//        Node node = token.getNode();
//        //如果当前任务节点不是该令牌的执行节点,则直接返回
//        if (!node.equals(this)) {
//            throw new WorkFlowException("令牌已经流转到节点[" + node.getName() + "]," +
//                                        "不能执行撤回操作!");
//        }
//
//        //获得流程实例
//        ProcessInstance instance = token.getProcessInstance();
//        //获得任务
//        AbstractTask task = AbstractTask.getTask(instance, this);
//
//        //如果该任务处于创建和分配用户状态,则返回true
//        if (task.getStatus() == AbstractTask.STATUS_CREATE ||
//            task.getStatus() == AbstractTask.STATUS_ASSIGN) {
//
//            //删除该任务项
//            token.removeTask(task);
//
//            //把当前节点从令牌的执行路径中删除
//            token.removeExecutedNode(this);
//
//        } else {
//            throw new WorkFlowException("该节点[" + this.getName() + "]任务的状态为:" +
//                                        task.getStatus() + ",不能执行撤回操作!");
//        }
//
//    }

    /**
     * 功能描述:
     *    获得所有的前置任务节点
     * @return List
     */
    public Set<TaskNode> getPreviousTaskNodes() {

        Set<TaskNode> previousNodes = new HashSet<TaskNode>();
//        Iterator itor = this.getArrivingTransitions().iterator();
//        while(itor.hasNext()) {
//            Transition arriveTra = (Transition)itor.next();
//            Node node = arriveTra.getFromNode();
//            if (EqualsUtil.isInstance(node,TaskNode.class)) {
//                previousNodes.add((TaskNode)node);
//                previousNodes.addAll(getPreviousTaskNodes(node));
//            }
//            else {
//                previousNodes.addAll(getPreviousTaskNodes(node));
//            }
//        }
        return previousNodes;
    }

    /**
     * 功能描述:
     *    获得指定任务节点的前置节点
     * @param
     * @return List
     */
    private Set<TaskNode> getPreviousTaskNodes(Node currentNode) {

        Set<TaskNode> previousNodes = new HashSet<TaskNode>();
//        Iterator itor = currentNode.getArrivingTransitions().iterator();
//        while(itor.hasNext()) {
//            Transition arriveTra = (Transition)itor.next();
//            Node node = arriveTra.getFromNode();
//            if (EqualsUtil.isInstance(node,TaskNode.class)) {
//                previousNodes.add((TaskNode)node);
//                previousNodes.addAll(getPreviousTaskNodes(node));
//            }
//            else {
//                previousNodes.addAll(getPreviousTaskNodes(node));
//            }
//        }
        return previousNodes;

    }


}
